﻿using System.Text.Json;
using System.Text.Json.Nodes;

namespace DifyToOpenAI.Common
{
    /// <summary>
    /// 提供 JSON 配置文件的读取、写入、更新和删除操作的帮助类。
    /// </summary>
    public static class JsonAppConfigHelper
    {
        private static Dictionary<string, string> configDic = new Dictionary<string, string>();

         public static string AppConfigDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "configs");
       // public static string AppConfigDirectory = AppDomain.CurrentDomain.BaseDirectory;
        public static string AppConfigPathFile = Path.Combine(AppConfigDirectory, "config.json");
        public static string ModelListPathFile = Path.Combine(AppConfigDirectory, "modellist.json");

        /// <summary>
        /// JSON 序列化配置选项，允许更人性化的打印格式。
        /// </summary>
        public static JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions
        {
            Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
            WriteIndented = true
        };

        /// <summary>
        /// 删除指定键的配置信息，并更新配置文件。
        /// </summary>
        /// <param name="key">需要删除的键。</param>
        /// <param name="path">配置文件路径，若为空则使用默认路径。</param>
        public static void DeleteConfig(string key, string path = "")
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                path = AppConfigPathFile;
            }

            if (configDic.ContainsKey(key))
            {
                configDic.Remove(key);
                string serializedData = JsonSerializer.Serialize(configDic, JsonSerializerOptions);
                File.WriteAllText(path, serializedData);
            }
        }

        /// <summary>
        /// 读取配置文件中的 JSON 字符串。
        /// </summary>
        /// <param name="path">配置文件路径，若为空则使用默认路径。</param>
        /// <returns>配置文件中的 JSON 字符串。</returns>
        public static string ReadConfigJson(string path = "")
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                path = AppConfigPathFile;
            }

            CheckFilePathCreate();

            try
            {
                if (!File.Exists(path))
                {
                    using (FileStream fileStream = File.Create(path))
                    {
                        // 文件创建后立即关闭。
                    }
                }
                return File.ReadAllText(path);
            }
            catch (Exception)
            {
                //Console.WriteLine($"读取配置文件时出错: {ex.Message}");
                return string.Empty;
            }
        }

        /// <summary>
        /// 读取配置文件中的所有键值对。
        /// </summary>
        /// <param name="path">配置文件路径，若为空则使用默认路径。</param>
        /// <returns>配置文件中的键值对字典。</returns>
        public static Dictionary<string, string> ReadAllConfigByPath(string path = "")
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                path = AppConfigPathFile;
            }

            Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();

            try
            {
                if (File.Exists(path))
                {
                    string fileContent = File.ReadAllText(path);

                    /*
                JsonCommentHandling 是一个枚举，有三个值：
Disallow (默认值): 不允许注释，如果找到注释则抛出异常。
Skip: 允许注释，并忽略它们，解析器会像没有注释一样处理 JSON。
Allow: 允许注释，并将其作为有效令牌处理（通常用于更高级的场景，例如读取注释本身，但在 JsonNode.Parse 的直接使用中，Skip 更常见和实用）。
                */
                    // 创建 JsonDocumentOptions 实例并设置 CommentHandling 为 Skip
                    var documentOptions = new JsonDocumentOptions
                    {
                        CommentHandling = JsonCommentHandling.Skip,//允许注释，并忽略它们，解析器会像没有注释一样处理 JSON。
                        AllowTrailingCommas = true // 允许或禁止 JSON 数据中的尾随逗号。
                    };

                    JsonNode? jsonNode = JsonNode.Parse(fileContent, documentOptions: documentOptions);
                    foreach (var item in jsonNode!.AsObject())
                    {
                        keyValuePairs.Add(item.Key, item.Value!.ToString());
                    }
                    //keyValuePairs= JsonSerializer.Deserialize<Dictionary<string, string>>(jsonNode!, JsonSerializerOptions)!;
                    //keyValuePairs = JsonSerializer.Deserialize<Dictionary<string, string>>(fileContent, JsonSerializerOptions)
                    //    ?? new Dictionary<string, string>();
                }
            }
            catch (Exception)
            {
                //Console.WriteLine($"读取配置文件时出错: {ex.Message}");
            }

            return keyValuePairs;
        }

        /// <summary>
        /// 根据键添加或更新配置，并写入到配置文件。
        /// </summary>
        /// <param name="key">需要添加或更新的键。</param>
        /// <param name="value">键对应的值。</param>
        /// <param name="path">配置文件路径，若为空则使用默认路径。</param>
        public static void AddOrUpdateConfigByKeyPath(string key, string value, string path = "")
        {
            CheckFilePathCreate();

            if (string.IsNullOrWhiteSpace(path))
            {
                path = AppConfigPathFile;
            }

            Dictionary<string, string> keyValuePairs = ReadAllConfigByPath(path);

            if (keyValuePairs.ContainsKey(key))
            {
                keyValuePairs[key] = value;
            }
            else
            {
                keyValuePairs.Add(key, value);
            }

            string serializedData = JsonSerializer.Serialize(keyValuePairs, JsonSerializerOptions);
            File.WriteAllText(path, serializedData);
        }

        /// <summary>
        /// 获取服务器 URL，确保以斜杠结尾。
        /// </summary>
        /// <param name="url">服务器 URL。</param>
        /// <returns>格式化后的服务器 URL。</returns>
        public static string GetServerUrl(string url)
        {
            if (string.IsNullOrWhiteSpace(url))
            {
                return string.Empty;
            }

            return url.EndsWith("/") ? url : url + "/";
        }

        /// <summary>
        /// 删除配置文件中的所有内容。
        /// </summary>
        /// <param name="path">配置文件路径。</param>
        public static void DeleteAllConfig(string path)
        {
            CheckFilePathCreate();

            if (!File.Exists(path))
            {
                using (FileStream fileStream = File.Create(path))
                {
                    // 文件创建后立即关闭。
                }
            }

            var emptyConfig = new Dictionary<string, string>();
            string serializedData = JsonSerializer.Serialize(emptyConfig, JsonSerializerOptions);
            File.WriteAllText(path, serializedData);
        }

        /// <summary>
        /// 检查并创建配置文件夹路径。
        /// </summary>
        public static void CheckFilePathCreate()
        {
            if (!Directory.Exists(AppConfigDirectory))
            {
                Directory.CreateDirectory(AppConfigDirectory);
            }
        }
    }
}
